/*
 * Rust 整数类型初探 - i8, i16, i32, i64
 * 
 * 本程序详细介绍了Rust中的有符号整数类型，包括：
 * - i8:  8位有符号整数  （-128 到 127）
 * - i16: 16位有符号整数 （-32,768 到 32,767）  
 * - i32: 32位有符号整数 （-2,147,483,648 到 2,147,483,647）
 * - i64: 64位有符号整数 （-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807）
 * 
 * 学习目标：
 * 1. 理解不同整数类型的存储大小和范围
 * 2. 掌握整数变量的声明和赋值
 * 3. 了解类型推断和显式类型注解
 * 4. 学习各种整数类型的实际应用场景
 */

fn main() {
    println!("🦀 欢迎学习 Rust 整数类型！");
    println!("{}", "=".repeat(50));
    
    // ===== 第一部分：基本整数类型声明 =====
    println!("\n📌 第一部分：基本整数类型声明");
    
    // i8: 8位有符号整数，占用1个字节
    // 范围：-128 到 127
    let small_number: i8 = 42;
    let negative_small: i8 = -100;
    
    println!("i8 类型示例：");
    println!("  正数: {} (占用 {} 字节)", small_number, std::mem::size_of::<i8>());
    println!("  负数: {} (占用 {} 字节)", negative_small, std::mem::size_of::<i8>());
    
    // i16: 16位有符号整数，占用2个字节  
    // 范围：-32,768 到 32,767
    let medium_number: i16 = 30000;
    let negative_medium: i16 = -25000;
    
    println!("\ni16 类型示例：");
    println!("  正数: {} (占用 {} 字节)", medium_number, std::mem::size_of::<i16>());
    println!("  负数: {} (占用 {} 字节)", negative_medium, std::mem::size_of::<i16>());
    
    // i32: 32位有符号整数，占用4个字节
    // 这是Rust中整数的默认类型！
    // 范围：-2,147,483,648 到 2,147,483,647
    let large_number: i32 = 2_000_000;  // 可以用下划线分隔数字，增强可读性
    let negative_large: i32 = -1_500_000;
    
    println!("\ni32 类型示例（默认整数类型）：");
    println!("  正数: {} (占用 {} 字节)", large_number, std::mem::size_of::<i32>());
    println!("  负数: {} (占用 {} 字节)", negative_large, std::mem::size_of::<i32>());
    
    // i64: 64位有符号整数，占用8个字节
    // 范围：-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
    let huge_number: i64 = 9_000_000_000_000;
    let negative_huge: i64 = -5_000_000_000_000;
    
    println!("\ni64 类型示例：");
    println!("  正数: {} (占用 {} 字节)", huge_number, std::mem::size_of::<i64>());
    println!("  负数: {} (占用 {} 字节)", negative_huge, std::mem::size_of::<i64>());
    
    // ===== 第二部分：类型推断与默认类型 =====
    println!("\n📌 第二部分：类型推断与默认类型");
    
    // Rust 可以自动推断类型
    let auto_inferred = 100;  // 默认推断为 i32 类型
    println!("自动推断的整数类型: {} (默认为 i32，占用 {} 字节)", 
             auto_inferred, std::mem::size_of_val(&auto_inferred));
    
    // 可以通过后缀明确指定类型
    let explicit_i8 = 50i8;
    let explicit_i16 = 1000i16; 
    let explicit_i32 = 100000i32;
    let explicit_i64 = 10000000000i64;
    
    println!("\n使用后缀明确指定类型：");
    println!("  50i8 = {}", explicit_i8);
    println!("  1000i16 = {}", explicit_i16);
    println!("  100000i32 = {}", explicit_i32);
    println!("  10000000000i64 = {}", explicit_i64);
    
    // ===== 第三部分：整数类型的范围展示 =====
    println!("\n📌 第三部分：各整数类型的数值范围");
    
    println!("i8  范围: {} 到 {}", i8::MIN, i8::MAX);
    println!("i16 范围: {} 到 {}", i16::MIN, i16::MAX);
    println!("i32 范围: {} 到 {}", i32::MIN, i32::MAX);
    println!("i64 范围: {} 到 {}", i64::MIN, i64::MAX);
    
    // ===== 第四部分：实际应用场景 =====
    println!("\n📌 第四部分：实际应用场景");
    
    // i8: 适用于小范围数值，如年龄、评分等
    let age: i8 = 25;
    let temperature: i8 = -10;  // 摄氏温度
    println!("i8 应用场景 - 年龄: {}岁, 温度: {}°C", age, temperature);
    
    // i16: 适用于中等范围，如端口号、小型计数器
    let port: i16 = 8080;
    let altitude: i16 = 2500;  // 海拔高度（米）
    println!("i16 应用场景 - 端口号: {}, 海拔: {}米", port, altitude);
    
    // i32: 最常用的整数类型，适用于大多数情况
    let population: i32 = 1_400_000_000;  // 人口数量
    let distance: i32 = 384_400;  // 地球到月球距离（千米）
    println!("i32 应用场景 - 人口: {}, 地月距离: {}千米", population, distance);
    
    // i64: 适用于非常大的数值，如时间戳、大数据计算
    let timestamp: i64 = 1694000000;  // Unix时间戳
    let national_debt: i64 = 31_000_000_000_000;  // 国债（美元）
    println!("i64 应用场景 - 时间戳: {}, 国债: {}美元", timestamp, national_debt);
    
    // ===== 第五部分：数字字面量的不同写法 =====
    println!("\n📌 第五部分：数字字面量的表示方法");
    
    let decimal = 1000;        // 十进制
    let hex = 0xff;           // 十六进制（255）
    let octal = 0o77;         // 八进制（63）
    let binary = 0b1111_0000; // 二进制（240）
    
    println!("不同进制的表示：");
    println!("  十进制: {}", decimal);
    println!("  十六进制 0xff: {}", hex);
    println!("  八进制 0o77: {}", octal);
    println!("  二进制 0b1111_0000: {}", binary);
    
    // ===== 第六部分：简单的数学运算 =====
    println!("\n📌 第六部分：基本数学运算");
    
    let a: i32 = 10;
    let b: i32 = 3;
    
    println!("数学运算示例 (a = {}, b = {})：", a, b);
    println!("  加法: {} + {} = {}", a, b, a + b);
    println!("  减法: {} - {} = {}", a, b, a - b);
    println!("  乘法: {} * {} = {}", a, b, a * b);
    println!("  除法: {} / {} = {}", a, b, a / b);  // 整数除法，结果为3
    println!("  取余: {} % {} = {}", a, b, a % b);
    
    // ===== 总结 =====
    println!("\n🎯 学习总结：");
    println!("1. Rust 提供了4种有符号整数类型：i8, i16, i32, i64");
    println!("2. i32 是默认的整数类型，适合大多数场景");
    println!("3. 选择合适的类型可以优化内存使用");
    println!("4. 可以使用下划线分隔数字增强可读性");
    println!("5. 支持十进制、十六进制、八进制、二进制字面量");
    
    println!("\n🚀 恭喜！你已经掌握了 Rust 整数类型的基础知识！");
}
